using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using 凌依.工具库;

public class 角色实体 : MonoBehaviour
{
    public 角色属性 属性;
    public List<增益效果> buff集合;//每秒计算一次
    public 角色装备集合 实体装备;
    public 角色贴图渲染 渲染;
    public 角色移动方向 状态;
    public Color 肤色;

    private void Start()
    {
        渲染.初始化(this);
    }
    private 角色移动方向 _状态;
    private void FixedUpdate()
    {
        if(_状态 != 状态)
        {
            _状态 = 状态;
            渲染.设置贴图(this);
        }
    }
}
[System.Serializable]
public enum 角色移动方向
{
    上,下,左,右
}
[System.Serializable]
public class 角色贴图渲染
{
    public SpriteRenderer 头部;
    public SpriteRenderer 头发;
    public SpriteRenderer 头部附件;
    public SpriteRenderer 躯干;
    public SpriteRenderer 服装;
    public SpriteRenderer 装甲;
    public SpriteRenderer 躯干附件;
    public SpriteRenderer 武器;

    public void 初始化(角色实体 参数)
    {
        设置叠加色(参数);
        头发.transform.position += 参数.实体装备.头发.偏移值.ToVector3();
        头部.transform.position += 参数.实体装备.头部.偏移值.ToVector3();
    }

    public void 设置贴图(角色实体 参数)
    {
        void 贴图设置(SpriteRenderer 渲染器,人形生物贴图 数据)
        {
            //渲染器.color = 数据.叠加色;
            switch (参数.状态)
            {
                case 角色移动方向.上:
                    渲染器.sprite = 数据.贴图.背面贴图;
                    break;
                case 角色移动方向.下:
                    渲染器.sprite = 数据.贴图.正面贴图;
                    break;
                case 角色移动方向.左:
                    渲染器.sprite = 数据.贴图.侧面贴图;
                    break;
                case 角色移动方向.右:
                    渲染器.sprite = 数据.贴图.侧面贴图;
                    break;
                default:
                    break;
            }
            
        }

        void 装备设置(SpriteRenderer 渲染器,角色装备 数据)
        {
            //渲染器.color = 数据.叠加色;
            switch (参数.状态)
            {
                case 角色移动方向.上:
                    渲染器.sprite = 数据.获取贴图(参数.属性.性别, 参数.属性.质量).背面贴图;
                    break;
                case 角色移动方向.下:
                    渲染器.sprite = 数据.获取贴图(参数.属性.性别, 参数.属性.质量).正面贴图;
                    break;
                case 角色移动方向.左:
                    渲染器.sprite = 数据.获取贴图(参数.属性.性别, 参数.属性.质量).侧面贴图;
                    break;
                case 角色移动方向.右:
                    渲染器.sprite = 数据.获取贴图(参数.属性.性别, 参数.属性.质量).侧面贴图;
                    break;
                default:
                    break;
            }
        }
        角色装备集合 a = 参数.实体装备;

        void 设置()
        {
            贴图设置(头部, a.头部);
            贴图设置(头发, a.头发);
            贴图设置(头部附件, a.头部附件);
            装备设置(躯干, a.肉体);
            装备设置(服装, a.内衣);
            装备设置(装甲, a.外套);
            装备设置(躯干附件, a.附件);
        }

        switch (参数.状态)
        {
            case 角色移动方向.上:
                头部.sortingOrder = -1;
                设置();
                break;
            case 角色移动方向.下:
                头部.sortingOrder = 3;
                设置();
                break;
            case 角色移动方向.左:
                //反转
                头部.sortingOrder = 3;
                Vector3 vector3 = 参数.transform.localScale;
                参数.transform.localScale = new Vector3(-Mathf.Abs(vector3.x), vector3.y, vector3.z);
                设置();
                break;
            case 角色移动方向.右:
                头部.sortingOrder = 3;
                Vector3 vector31 = 参数.transform.localScale;
                参数.transform.localScale = new Vector3(Mathf.Abs(vector31.x), vector31.y, vector31.z);
                设置();
                break;
            default:
                break;
        }
    }

    public void 设置叠加色(角色实体 参数)
    {
        头部.color = 参数.肤色;
        躯干.color = 参数.肤色;

        头发.color = 参数.实体装备.头发.叠加补色;

    }
}

[System.Serializable]
public class 角色装备集合
{
    public 人形生物贴图 头部;
    public 人形生物贴图 头发;
    public 人形生物贴图 头部附件;
    public 角色装备 头部装备;

    public 角色装备 肉体;
    public 角色装备 内衣;
    public 角色装备 外套;
    public 角色装备 附件;
}

[System.Serializable]
public class 人型生物_能力叠加信息
{
    public float 疼痛;
    public float 昏迷阈值;
    public float 意识;

    public float 移动能力;
    public float 操作能力;
    public float 语言能力;
    public float 进食速度;
    public float 视觉能力;
    public float 听觉能力;
    public float 呼吸能力;
    public float 血液过滤;
    public float 血液循环;
    public float 新陈代谢;
    public float 解毒能力;

    public float 学习系数;

    public float 瞄准精准度;
    public float 瞄准速度;

    public float 饱食度;
    public float 饱食度上限;

    public float 休息系数;

    public float 抗性;

    public float 心情;

    public void 移除属性列表(List<增益信息> item)
    {
        foreach (var item1 in item)
            移除属性(item1);
    }
    public void 移除属性(增益信息 item)
    {
        switch (item.效果名称)
        {
            case "学习系数":
                学习系数 -= item.系数;
                break;
            case "休息系数":
                休息系数 -= item.系数;
                break;
            case "听觉能力":
                听觉能力 -= item.系数;
                break;
            case "呼吸能力":
                呼吸能力 -= item.系数;
                break;
            case "心情":
                心情 -= item.系数;
                break;
            case "抗性":
                抗性 -= item.系数;
                break;
            case "操作能力":
                操作能力 -= item.系数;
                break;
            case "新陈代谢":
                新陈代谢 -= item.系数;
                break;
            case "昏迷阈值":
                昏迷阈值 -= item.系数;
                break;
            case "瞄准精准度":
                瞄准精准度 -= item.系数;
                break;
            case "瞄准速度":
                瞄准速度 -= item.系数;
                break;
            case "移动能力":
                移动能力 -= item.系数;
                break;
            case "血液循环":
                血液循环 -= item.系数;
                break;
            case "血液过滤":
                血液过滤 -= item.系数;
                break;
            case "视觉能力":
                视觉能力 -= item.系数;
                break;
            case "语言能力":
                语言能力 -= item.系数;
                break;
            case "进食速度":
                进食速度 -= item.系数;
                break;
            case "饱食度上限":
                饱食度上限 -= item.系数;
                break;
            default:
                break;
        }
    }
    public void 叠加属性列表(List<增益信息> 信息)
    {
        foreach (var item in 信息)
            叠加属性(item);
    }
    public void 叠加属性(增益信息 item)
    {
        switch (item.效果名称)
        {
            case "学习系数":
                学习系数 += item.系数;
                break;
            case "休息系数":
                休息系数 += item.系数;
                break;
            case "听觉能力":
                听觉能力 += item.系数;
                break;
            case "呼吸能力":
                呼吸能力 += item.系数;
                break;
            case "心情":
                心情 += item.系数;
                break;
            case "抗性":
                抗性 += item.系数;
                break;
            case "操作能力":
                操作能力 += item.系数;
                break;
            case "新陈代谢":
                新陈代谢 += item.系数;
                break;
            case "昏迷阈值":
                昏迷阈值 += item.系数;
                break;
            case "瞄准精准度":
                瞄准精准度 += item.系数;
                break;
            case "瞄准速度":
                瞄准速度 += item.系数;
                break;
            case "移动能力":
                移动能力 += item.系数;
                break;
            case "血液循环":
                血液循环 += item.系数;
                break;
            case "血液过滤":
                血液过滤 += item.系数;
                break;
            case "视觉能力":
                视觉能力 += item.系数;
                break;
            case "语言能力":
                语言能力 += item.系数;
                break;
            case "进食速度":
                进食速度 += item.系数;
                break;
            case "饱食度上限":
                饱食度上限 += item.系数;
                break;
            case "解毒能力":
                解毒能力 += item.系数;
                break;
            default:
                break;
        }
    }
}

[System.Serializable]
public class 角色属性
{
    public string 初始基因;//md5值 由初始器官名称拼接 加 角色技能等级上限 组成   用于 基因库的键 繁殖时调用基因库杂交
    public int 基因优越度;//角色会根据 基因优越度 选择交配  计算方式 角色技能等级上限相加+所有初始有机器官的基因优越度 出生时计算

    public 人型生物_能力叠加信息 能力叠加信息;
    public 角色器官 器官集合;
    public 角色技能 技能;


    public float 休息度;
    public float 休息度上限;
    public float 心情上限;
    public string 种族;
    public string 名称;

    public int 质量;
    public string 性别;

    #region 更换器官
    public 器官信息 更换器官(ref 器官信息 老器官, 器官信息 新器官,string 类型)
    {
        if (新器官.器官类型 != 类型)
            return null;

        器官信息 old = 老器官;
        if(old!=null)
            能力叠加信息.移除属性列表(old.增益属性);
        能力叠加信息.叠加属性列表(新器官.增益属性);
        老器官 = 新器官;
        return old;
    }

    public 器官信息 更换大脑(器官信息 新器官) => 更换器官(ref 器官集合.大脑, 新器官, "大脑");
    public 器官信息 更换皮肤(器官信息 新器官) => 更换器官(ref 器官集合.皮肤, 新器官, "皮肤");

    public 器官信息 更换左眼(器官信息 新器官) => 更换器官(ref 器官集合.左眼, 新器官, "眼睛");
    public 器官信息 更换右眼(器官信息 新器官) => 更换器官(ref 器官集合.右眼, 新器官, "眼睛");

    public 器官信息 更换下颚(器官信息 新器官) => 更换器官(ref 器官集合.下颚, 新器官, "下颚");

    public 器官信息 更换左耳(器官信息 新器官) => 更换器官(ref 器官集合.左耳, 新器官, "耳朵");
    public 器官信息 更换右耳(器官信息 新器官) => 更换器官(ref 器官集合.右耳, 新器官, "耳朵");

    public 器官信息 更换心脏(器官信息 新器官) => 更换器官(ref 器官集合.心脏, 新器官, "心脏");
    public 器官信息 更换血液(器官信息 新器官) => 更换器官(ref 器官集合.血液, 新器官, "血液");
    public 器官信息 更换躯干(器官信息 新器官) => 更换器官(ref 器官集合.躯干, 新器官, "躯干");
    public 器官信息 更换脊椎(器官信息 新器官) => 更换器官(ref 器官集合.脊椎, 新器官, "脊椎");

    public 器官信息 更换左肺(器官信息 新器官) => 更换器官(ref 器官集合.左肺, 新器官, "肺部");
    public 器官信息 更换右肺(器官信息 新器官) => 更换器官(ref 器官集合.右肺, 新器官, "肺部");

    public 器官信息 更换胃部(器官信息 新器官) => 更换器官(ref 器官集合.胃部, 新器官, "胃部");
    public 器官信息 更换左肾(器官信息 新器官) => 更换器官(ref 器官集合.左肾, 新器官, "肾脏");
    public 器官信息 更换右肾(器官信息 新器官) => 更换器官(ref 器官集合.右肾, 新器官, "肾脏");
    public 器官信息 更换肝脏(器官信息 新器官) => 更换器官(ref 器官集合.肝脏, 新器官, "肝脏");

    public 器官信息 更换左臂(器官信息 新器官) => 更换器官(ref 器官集合.左臂, 新器官, "手臂");
    public 器官信息 更换右臂(器官信息 新器官) => 更换器官(ref 器官集合.右臂, 新器官, "手臂");
    public 器官信息 更换左腿(器官信息 新器官) => 更换器官(ref 器官集合.左腿, 新器官, "腿部");
    public 器官信息 更换右腿(器官信息 新器官) => 更换器官(ref 器官集合.右腿, 新器官, "腿部");
    #endregion

}

public enum 伤害类型
{
    刀伤,枪伤,炸伤,激光武器
}

[System.Serializable]
public class 角色器官
{
    public 器官信息 大脑;//大脑可移植  包括技能经验

    public 器官信息 皮肤;

    public 器官信息 左眼;
    public 器官信息 右眼;

    public 器官信息 下颚;

    public 器官信息 左耳;
    public 器官信息 右耳;

    public 器官信息 心脏;

    public 器官信息 血液;

    public 器官信息 躯干;

    public 器官信息 脊椎;

    public 器官信息 左肺;
    public 器官信息 右肺;

    public 器官信息 胃部;

    public 器官信息 左肾;
    public 器官信息 右肾;

    public 器官信息 肝脏;

    public 器官信息 左臂;
    public 器官信息 右臂;

    public 器官信息 左腿;
    public 器官信息 右腿;

    public void 受到攻击(伤害类型 类型,int 伤害)//未完成
    {
        switch (类型)
        {
            case 伤害类型.刀伤://大概率四肢躯干 小几率内脏伤害 根据刀的伤害改变攻击到内脏的几率
                break;
            case 伤害类型.枪伤://贯穿伤害 大概率四肢躯干 中概率内脏伤害  伤害改变攻击到内脏的几率
                break;
            case 伤害类型.炸伤://范围伤害 大概率内伤 四肢躯干重伤  
                break;
            case 伤害类型.激光武器://范围贯穿伤害  躯干与内伤几率相当
                break;
            default:
                break;
        }
    }



    public bool 判断死亡()
    {
        if (大脑.耐久 <= 0)
            return true;
        if (心脏.耐久 <= 0)
            return true;
        if (左肺.耐久 <= 0 && 右肺.耐久 <= 0)
            return true;
        return false;
    }
}

[System.Serializable]
public class 增益信息
{

    public string 效果名称;
    public float 系数;

    public 增益信息() { }

    public 增益信息(string 效果名称, float 系数)
    {
        this.效果名称 = 效果名称;
        this.系数 = 系数;
        

    }
}

[System.Serializable]
public class 技能经验信息
{
    public string 技能名;
    public int 当前经验;
    public int 最大经验;

    public int 当前等级;
    public int 最大等级;//来自基因
    public float 学习系数;

    public 技能经验信息()
    {

    }

    public 技能经验信息(string 技能名, int 当前经验, int 最大经验, int 当前等级, int 最大等级, float 学习系数)
    {
        this.技能名 = 技能名;
        this.当前经验 = 当前经验;
        this.最大经验 = 最大经验;
        this.当前等级 = 当前等级;
        this.最大等级 = 最大等级;
        this.学习系数 = 学习系数;
    }
}

[System.Serializable]
public class 器官信息 : 道具模板
{
    public List<增益信息> 增益属性;
    public int 耐久;//器官生命
    public int 基因优越度;
    public string 器官类型;
    public bool 有机体;//当为有机体时可 遗传给子代
}

[System.Serializable]
public class 角色技能
{
    public List<技能经验信息> 技能 = new List<技能经验信息>();
    //有关技能的操作写在此处
}